home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / packet / p_aa4re / bb212src / bbsrt23i.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1990-10-26  |  8.9 KB  |  226 lines
  1. (*===========================================================================*)
  2. (* Procedure to send/receive things to the PK232 in block mode               *)
  3. (*                                                                           *)
  4. (*   Copyright 1988, 1989, 1990 by H. Roy Engehausen.  All rights reserved.  *)
  5. (*   This software may be freely distributed and used, but it may not        *)
  6. (*   under any circumstances be sold by anyone other than the author.        *)
  7. (*   It may be distributed by a commercial company as long as it is          *)
  8. (*   for no cost.                                                            *)
  9. (*                                                                           *)
  10. (*===========================================================================*)
  11.  
  12. PROCEDURE pk232_io;
  13.  
  14.   TYPE
  15.     over_array = ARRAY[1..512] OF BYTE;
  16.  
  17.   VAR
  18.  
  19.     byte_array     : ^over_array;
  20.     byte_count     : WORD;
  21.     set_dx         : BYTE;
  22.     times_up       : LONGINT;
  23.     tnc_registers  : REGISTERS;
  24.  
  25.   BEGIN;
  26.  
  27.     (*-----------------------------------------------------------------------*)
  28.     (* If this is master task then time check                                *)
  29.     (*-----------------------------------------------------------------------*)
  30.  
  31.     IF master_thread THEN
  32.       time_check;
  33.  
  34.     (*-----------------------------------------------------------------------*)
  35.     (* Save the COM number for later use                                     *)
  36.     (*-----------------------------------------------------------------------*)
  37.  
  38.     set_dx := active_port^.com_number - 1;
  39.  
  40.     (*-----------------------------------------------------------------------*)
  41.     (* Ok.  Get addressing for transmit                                      *)
  42.     (*-----------------------------------------------------------------------*)
  43.  
  44.     WITH active_tcb^.tnc_htt^, tnc_registers DO
  45.       BEGIN;
  46.  
  47.         (*-------------------------------------------------------------------*)
  48.         (* See if junk around?                                               *)
  49.         (*-------------------------------------------------------------------*)
  50.  
  51.         AX := $0300;
  52.         DX := set_dx;
  53.  
  54.         signal_place^ := $0200 + LO(signal_place^);
  55.  
  56.         INTR(tnc_interrupt, tnc_registers);
  57.  
  58.         signal_place^ := $F800 + LO(signal_place^);
  59.  
  60.         AH := AH AND lsr_8250_dr;
  61.         IF AH <> 0 THEN
  62.           window_write_critical('Garbage from TNC -- '
  63.                                                     + active_tcb^.port_chan_s
  64.                                                     + ' -- ',
  65.                                  garbage_collect_tnc);
  66.  
  67.         (*-------------------------------------------------------------------*)
  68.         (* Transmit it!                                                      *)
  69.         (*-------------------------------------------------------------------*)
  70.  
  71.         AX := $0A00;
  72.         CX := pk232_len;
  73.         DX := set_dx;
  74.         DI := OFS(pk232_buff^);
  75.         ES := SEG(pk232_buff^);
  76.  
  77.         signal_place^ := $0100 + LO(signal_place^);
  78.  
  79.         INTR(tnc_interrupt, tnc_registers);
  80.  
  81.         signal_place^ := $7800 + LO(signal_place^);
  82.  
  83.       END;
  84.  
  85.     (*-----------------------------------------------------------------------*)
  86.     (* If outgoing data then we are done                                     *)
  87.     (*-----------------------------------------------------------------------*)
  88.  
  89.     IF tnc_cmd_data = info_cmd_info THEN
  90.       EXIT;
  91.  
  92.     (*-----------------------------------------------------------------------*)
  93.     (* Ok.  Get addressing for receive                                       *)
  94.     (*-----------------------------------------------------------------------*)
  95.  
  96.     WITH active_tcb^.tnc_tth^, tnc_registers DO
  97.       BEGIN;
  98.  
  99.         byte_count := 0;
  100.  
  101.         times_up := up_time + time_out_value;
  102.  
  103.         (*-------------------------------------------------------------------*)
  104.         (* Initialize                                                        *)
  105.         (*-------------------------------------------------------------------*)
  106.  
  107.         CX := SIZEOF(pk232_buff^);
  108.         DI := OFS(pk232_buff^);
  109.         ES := SEG(pk232_buff^);
  110.  
  111.         byte_array := @pk232_buff^;
  112.         byte_count := 0;
  113.  
  114.         (*-------------------------------------------------------------------*)
  115.         (* Loop reading the data                                             *)
  116.         (*-------------------------------------------------------------------*)
  117.  
  118.         WHILE TRUE DO
  119.           BEGIN;
  120.  
  121.             task_switch;
  122.  
  123.             (*---------------------------------------------------------------*)
  124.             (* Receive it                                                    *)
  125.             (*---------------------------------------------------------------*)
  126.  
  127.             AX := $0B00;
  128.             CX := SIZEOF(pk232_buff^) - byte_count;
  129.             DX := set_dx;
  130.  
  131.             signal_place^ := $0200 + LO(signal_place^);
  132.  
  133.             INTR(tnc_interrupt, tnc_registers);
  134.  
  135.             signal_place^ := $F800 + LO(signal_place^);
  136.  
  137.             byte_count := byte_count + CX;
  138.  
  139.             (*---------------------------------------------------------------*)
  140.             (* Check for overrun                                             *)
  141.             (*---------------------------------------------------------------*)
  142.  
  143.             IF (AH AND lsr_8250_or) <> 0 THEN
  144.               BEGIN;
  145.                 window_write_critical_i('Overrun in block loop -- '
  146.                                                      + active_tcb^.port_chan_s
  147.                                                      + ' -- Count = ',
  148.                                                       byte_count);
  149.                 IF p_type = port_aeapk232 THEN
  150.                   BEGIN;
  151.                     IF byte_count <= 5 THEN
  152.                       WHILE byte_count <= 10 DO
  153.                         BEGIN;
  154.                           INC(byte_count);
  155.                           byte_array^[byte_count] := $0;
  156.                         END;
  157.                     EXIT;
  158.                   END;
  159.               END;
  160.  
  161.             (*---------------------------------------------------------------*)
  162.             (* Check for clock update need                                   *)
  163.             (*---------------------------------------------------------------*)
  164.  
  165.             IF master_thread THEN
  166.               time_check;
  167.  
  168.             (*---------------------------------------------------------------*)
  169.             (* Check for time out                                            *)
  170.             (*---------------------------------------------------------------*)
  171.  
  172.             IF (times_up <= up_time) AND (CX = 0) THEN
  173.               BEGIN;
  174.                 window_write_critical_i('Timeout in block loop -- '
  175.                                                      + active_tcb^.port_chan_s
  176.                                                      + ' -- Count = ',
  177.                                                       byte_count);
  178.                 IF byte_count <= 5 THEN
  179.                   WHILE byte_count <= 10 DO
  180.                     BEGIN;
  181.                       INC(byte_count);
  182.                       byte_array^[byte_count] := $0;
  183.                     END;
  184.                 EXIT;
  185.               END;
  186.  
  187.             (*---------------------------------------------------------------*)
  188.             (* See if end yet                                                *)
  189.             (*---------------------------------------------------------------*)
  190.  
  191.             IF byte_count >= 2 THEN
  192.               BEGIN;
  193.  
  194.                 (*-----------------------------------------------------------*)
  195.                 (* Watch for weirdos                                         *)
  196.                 (*-----------------------------------------------------------*)
  197.  
  198.                 IF byte_count > SIZEOF(over_array) THEN
  199.                   BEGIN;
  200.                     window_write_critical_i('Buffer overrun on '
  201.                                                      + active_tcb^.port_chan_s
  202.                                                      + ' -- Count = ',
  203.                                                       byte_count);
  204.                     byte_array^[1] := 0;
  205.                     byte_count     := 1;
  206.                   END;
  207.  
  208.                 (*-----------------------------------------------------------*)
  209.                 (* Look for ETB                                              *)
  210.                 (*-----------------------------------------------------------*)
  211.  
  212.                 IF (byte_array^[byte_count] = ORD(etb)) AND
  213.                                   (byte_array^[byte_count-1] <> ORD(dle)) THEN
  214.                   BEGIN;
  215.                     pk232_len := byte_count;
  216.                     EXIT;
  217.                   END;
  218.  
  219.               END;
  220.  
  221.           END; (*----- End loop for receiving the response ------------------*)
  222.  
  223.       END;
  224.  
  225.   END;
  226.